﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using AForge.Math;
using AForge.Imaging;
using AForge.Neuro;

namespace redes_neuronales_ocr
{
    class ProcesamientoDeImagen
    {
        public void ConseguirPixeles(string path, Color[][] pixeles)
        {
            Bitmap img = new Bitmap(path);
            int alto = img.Height;
            int ancho = img.Width;
            for (int i = 0; i < alto; i++)
                for (int j = 0; j < ancho; j++)
                    pixeles[i][j] = img.GetPixel(i, j);
        }

        ///<summary>
        ///Separa una imagen en varios objetos atomicos.
        ///Link página de ayuda: http://www.aforgenet.com/framework/features/blobs_processing.html
        ///Sacar este link antes de la entrega!!!!
        ///</summary>
        ///<return>
        ///No devuelve nada.
        ///</return>
        ///<param name="path">
        /// Ruta de la imagen a procesar.
        ///</param>
        public Blob[] SepararObjectosEnImagen(string path)
        {
            Bitmap image = new Bitmap(path);
            // create an instance of blob counter algorithm
            BlobCounterBase bc = new BlobCounter();
            // set filtering options
            bc.FilterBlobs = true;
            bc.MinWidth = 5;
            bc.MinHeight = 5;
            // set ordering options
            bc.ObjectsOrder = ObjectsOrder.Size;
            // process binary image
            bc.ProcessImage(image);
            Blob[] blobs = bc.GetObjectsInformation();
            for (int i = 0; i < 50; i++)
            {
                // cada blob tiene un atributo imagen
                bc.ExtractBlobsImage(image, blobs[i], true);
            }
            return blobs;

        }

        /*
         * Reduce la imagen y devuelve un vector binario a partir de la misma
         * Tamanio del vector Resultado es 100
         */
        public static double[] procesarImagen(Bitmap imagen)
        {
            // Reduce la imagen a 10x10
            Bitmap imagenAchicada = new Bitmap(imagen, new Size(imagen.Width / 5, imagen.Height / 5));
            double[] resultado = new double[imagenAchicada.Width * imagenAchicada.Height];
            for (int i = 0; i < imagenAchicada.Height; i++)
            {
                for (int j = 0; j < imagenAchicada.Width; j++)
                {
                    Color pixel = imagenAchicada.GetPixel(i, j);
                    if ((pixel.R + pixel.G + pixel.B) / 3 < 50)
                        resultado[(i * imagenAchicada.Height) + j] = 1.0;
                    else
                        resultado[(i * imagenAchicada.Height) + j] = 0.0;
                }
            }
            return resultado;
        }


        /*
         * Devuelve un vector binario a partir de una imagen
         * Tamanio del vector Resultado es 100
         */
        public static double[] procesarImagen2(Bitmap imagen)
        {

            List<double> resultado = new List<double>();
            Color[][] matrizPixeles = new Color[imagen.Height][];
            //creo una matrix de Alto x Ancho para guardar los pixeles
            for (int i = 0; i < imagen.Width; i++)
            {
                matrizPixeles[i] = new Color[imagen.Width];
            }
            //cargo la matriz con los pixeles
            for (int i = 0; i < imagen.Height; i++)
            {
                for (int j = 0; j < imagen.Width; j++)
                {
                    matrizPixeles[i][j] = imagen.GetPixel(i, j);
                }
            }
            //recorro la matriz de pixeles por sectores de 10x10
            //y busco los pixeles pintados
            int[][] rangos = construirArrayDeRangos();
            foreach (int[] rangox in rangos) {
                foreach (int[] rangoy in rangos) {
                    int pixelesManchandos = 0;
                    foreach (int x in rangox) {
                        foreach (int y in rangoy) {
                            //Color pixel = imagen.GetPixel(x, y);
                            Color pixel = matrizPixeles[x][y];
                            if ((pixel.R + pixel.G + pixel.B) / 3 < 50)
                                pixelesManchandos++;
                            
                        }
                    }
                    if (pixelesManchandos > 0)
                        resultado.Add(1.0);
                    else
                        resultado.Add(0.0);
                }
            }

            return resultado.ToArray();
        }
        /*
         * Construye arrays de rangos. [0..10] [10..20] [20..30] [30..40] [40..50]
         */
        private static int[][] construirArrayDeRangos() {
            int[][] rangos = new int[5][];
            for (int i = 0; i < 5; i++) {
                rangos[i] = new int[10];
                int nroBase = i * 10;
                for (int j = 0; j < 10; j++)
                {
                    rangos[i][j] = nroBase + j;
                }    
            }
            return rangos;
        }
    }
}
